Post's problem for supertasks has both positive and negative solutions

The infinite time Turing machine analogue of Post’s problem, the question whether there are supertask degrees between 0 and the supertask jump 0▽, has in a sense both positive and negative solutions. Namely, in the context of the reals there are no degrees between 0 and 0▽, but in the context of sets of reals, there are; indeed, there are incomparable semi-decidable supertask degrees. Both arguments employ a kind of transfinite-injury construction which generalizes canonically to oracles. The supertask model of infinitary computation extends the operation of an ordinary Turing machine into transfinite ordinal time. The theory, of which we gave a full introductory account in [HamLew], leads naturally to notions of computability and semi-decidability for reals and sets of reals, as well as an oracle concept and two jump operators: the lightface ▽ and boldface H jumps. Left open in [HamLew] was the supertask analogue of Post’s problem, the question whether there are semidecidable degrees between 0 and the jump 0, or indeed, whether there are any degrees between 0 and 0 at all. Here, we prove that the answer is in a sense both positive and negative. The first author wishes to thank his hosts at Kobe University and the Japan Society for the Promotion of Science for their gracious support during the 1998 calendar year, as well as the CUNY Scholar Incentive program. His research has been supported in part by a grant from the PSC-CUNY Research Foundation. §1 The supertask machines 2 Main Theorem. Depending on the context, the supertask analogue of Post’s problem has both positive and negative solutions. Specifically: 1. In the context of the reals, there are no degrees strictly between 0 and 0. 2. In the context of sets of reals, there are degrees strictly between 0 and 0. Indeed, there are incomparable semi-decidable degrees. While the first statement illustrates how sharply the supertask recursion theory departs from the classical theory, the second hints at a broader analogy in the context of degrees on sets of reals. Indeed, the second statement is proved by adapting the classical Friedburg-Munchnik priority argument to construct countable incomparable semi-decidable sets. Both of these arguments employ a kind of transfinite-injury construction which relativizes canonically to any oracle A, so that first, there is no real z such that A ⊕ z is strictly between A and A, and second, there are A-incomparable A-semidecidable sets below A. §1 The supertask machines Let us quickly review here how the machines work. For a full account, see [HamLew]. The basic idea is to extend the operation of an ordinary Turing machine into transfinite ordinal time by defining the limit stages of computation. For convenience, we use a three-tape Turing machine model, with separate input, scratch, and output tapes. The successor stages of computation proceed, just as for an ordinary Turing machine, according to a finite program running with finitely many states. Thus, the head reads the tape, reflects on its state and then writes 0 or 1 on the tape and moves left, right or not at all according to the program’s rigid instructions. The new behavior occurs at a limit stage: the head is reset to the initial starting position; the machine is placed in the special limit state, just another of the finitely many states; and the values on the cells of the tape are updated by computing the lim sup of the previous cell values. With the limit stage configuration thus completely specified, the machine simply continues the computation. If the halt state is eventually reached, the machine gives as output whatever is written on the output tape. Since there is plenty of time for the machines to deal with infinite input and output, the natural context for the machines is Cantor space 2, which in this paper we denote by R and refer to as the set of reals. Thus, the machines provide notions of computable partial functions f .. R → R on the reals, as well as notions of decidable and semi-decidable sets of reals A ⊆ R. §1 The supertask machines 3 Just as with Turing machines, we can use a real as an oracle by simply adding an extra oracle tape on which the oracle real is written, and allow the machine freely to consult this oracle tape during the computations. But because the machines provide a notion of decidability and semi-decidability for sets of reals A ⊆ R, we really want an oracle concept also in this case, though of course we can’t expect to somehow write out an uncountable set A on the tape. Instead, for an oracle A ⊆ R, we allow the machine to make membership queries of A, by writing out any real x on a special oracle tape and when in the query state receiving the answer yes or no whether x ∈ A or not. Thus, in parallel with the notion of constructibility from a predicate, as in the definition of L[A], the machine is allowed to know whether x ∈ A or not for any x which it is able to produce. The oracle concept leads in turn to the notions of relative decidability and the infinite time Turing degrees. In [HamLew] we presented the basic structural properties of the infinite time Turing degrees, and we aim now to build on that foundation. We will follow as closely as possible the notation of [HamLew]. In particular, we write φp (x) to denote the output of program p on input x with oracle A, and we write φp,α(x) ↓ to mean that the computation of program p on input x converges in fewer than α many steps. We will generally denote reals by a, b, c and x, y, z and sets of reals by A, B and C. Thus, when we mention oracles A and a without further explanation, we intend that A should be taken as a set of reals and a as an individual real. Since we proved in [HamLew] that every real x is equivalent to the set Ax of truncated initial segments of x (with 0s appended), the case of set oracles A subsumes that of real oracles a. We write A ≤ ∞ B to mean that the characteristic function of A is computable from B. This leads naturally to the strict computability relation < ∞ and the degree relation ≡ ∞ . The lightface halting problem is 0 = h = { p | φp(0) ↓ }, with the corresponding lightface jump defined by A = A⊕ h where h is the set { p | φp (0) ↓ }. Similarly, the boldface halting problem is 0 = { 〈 p, x 〉 | φp(x) ↓ }, with the corresponding boldface jump defined by A = { 〈 p, x 〉 | φp (x) ↓ }. In [HamLew] we proved, for example, that A < ∞ A < ∞ A. If y is a real coding a relation ⊳ on (a subset of) ω with order type α, then y ↾ β is the real coding the restriction of the relation ⊳ to its first β many elements. An ordinal is writable if there is a machine which on input 0 gives as output a real coding that ordinal. An §1 The supertask machines 4 ordinal is clockable when it is the length of a halting infinite time Turing machine computation. As always, we denote the supremum of the writable ordinals by λ and the supremum of the clockable ordinals by γ. A real is eventually writable when it eventually appears on the output tape during the computation of an infinite time Turing machine on input 0, never subsequently to be changed (but the machine need not halt). A real is accidently writable when it appears on one of the tapes during a computation on input 0. We say that an ordinal is eventually or accidentally writable when it is coded by a real which is, respectively, eventually or accidentally writable. We denote the supremum of the eventually writable ordinals by ζ and the supremum of the accidently writable ordinals by Σ. The results of [HamLew] establish, for example, that λ ≤ γ and λ < ζ < Σ. The proof of our Main Theorem has been considerably simplified by the recent result of Philip Welch [Wel98a] which answers what was probably the primary open question of [HamLew], namely, the question whether every clockable ordinal is writable. Let us therefore paraphrase Welch’s argument here. Theorem 1.1 (Welch) Every clockable ordinal is writable. In particular, λ = γ. Proof: By results of [HamLew], it suffices to show that ζ > γ. (The basic reason for this is that there can be no clockable ordinals between λ and ζ, indeed, between λ and Σ, for if β is clockable and accidently writable, then we can search for a real coding an ordinal which is long enough to support that computation, and halt when we find one. So β would be writable. Thus, in order to prove γ = λ it suffices to show that ζ > γ.) We begin by showing that in any computation on input 0, if a cell is 0 at Σ, then in fact it must be 0 for the entire time between ζ and Σ. Thus in fact it must stabilize before ζ, being 0 from some point on. Suppose some cell is 0 at Σ for the computation of program p on input 0. We will describe an algorithm which eventually writes a real coding an ordinal which is at least as large as the stabilizing stage of that cell, the stage at which it turns 0 never to change again before Σ. On the side, our algorithm simulates all programs on input 0, and thereby produces a steady stream of all accidentally writable reals coding ordinals. For each such real w produced, the algorithm simultates the computation of p along the ordinal α coded by w, and looks for the stage β when the values of the cell have stabilized at 0, if indeed they have stabilized before α. Using w the algorithm is able to write a real coding β. Now, the algorithm checks the output tape to see if the real on the output tape codes an ordinal at least as large as β. If so, the algorithm leaves §2 A negative solution to Post’s problem for supertasks 5 the output tape unchanged. If β is larger than what appears on the output tape, then the algorithm replaces the output tape with the real coding β. The key idea is that eventually the algorithm will see accidentally writable ordinals which are larger than the true stabilizing point below Σ, and at such a stage, we will write an ordinal which is at least as large as the true stabilizing point on the output tape. After this, the output tape will never change, because no other accidentally writable real can support a computation with a larger stabilizing point than the true stabilizing point. Thus, our algorithm eventually writes an ordinal which is at least as large as the stabilizing point of the computation, so this stabilizing point must be eventually writable, as we claimed. Similarly, if a cell is eventually 1 before Σ, then in fact it must be 1 the entire time between ζ and Σ, and in fact must be 1 constantly from some point before ζ. What the discussion until now shows is that the stage Σ snapshot of any computation on input 0 is the same as the stage ζ snapshot, and this is true in the strong sense that any cell which is 0 at Σ is 0 between ζ and Σ. Consequently, any computation which does not halt by ζ will be endlessly repeating. Consequently, ζ is at least as large as γ. Theorem The proof proceeded by establishing the following fact. Lemma 1.2 (Welch) Any non-halting supertask computation on input 0 attains it’s repeating snapshot by stage ζ, and the stage ζ snapshot repeats at stage Σ. Of course, we mean this in the strong sense, so that no cell which is 0 at ζ ever turns to 1 between ζ and Σ; thus, the computation is truly in an endlessly repeating loop. The theorem generalizes easily to any oracle, so that we have λ = γ for any oracle A. §2 A negative solution to Post’s problem for supertasks Let us now prove the main theorem in the context of degrees represented by a real, namely, that there are no such degrees between 0 and 0. Thus, in the reals there are only two semi-decidable supertask degrees. Main Theorem 2.1 There are no reals z such that 0 < ∞ z < ∞ 0. Proof: Suppose towards a contradiction that 0 < ∞ z < ∞ 0. Thus, with oracle 0 there is a program p yielding a halting program on input 0 with output z. Consider now the algorithm with no oracle which computes approximations to 0 by simulating all computations and keeping track of which programs have halted. §2 A negative solution to Post’s problem for supertasks 6 Thus, at any stage, this algorithm has a current best guess for 0, namely, the set of programs which have halted on input 0 by that stage. Eventually, of course, by stage γ, the program will have simulated the computations for long enough so that all the programs which will ever halt have already halted, and the true approximation will be reached, the stage when the best approximation to 0 is actually 0 itself. Of course, our algorithm has no way of realizing that it has reached the true approximation, and will forever continue to simulate the computations, waiting for more programs to halt. In any case, for each of the approximations to 0 along the way, let our algorithm use it as an oracle with program p in an attempt to write the real z, and to continue doing so until the next better approximation to 0 is found. Eventually, of course, the true approximation to 0 will be reached, and this true approximation will support a computation by the program p yielding the real z (while our algorithm continues searching for better approximations to 0). This algorithm shows that the real z is eventually writable. Let us think a bit more about this algorithm. Suppose first that z is not produced by any of the proper approximations to 0, and first appears only after the true approximation 0 has been produced. In this case, with z as an oracle, we could recognize 0 as the first approximation to produce z with program p. This contradicts our assumption that z < ∞ 0. Therefore, second, it must be that z is produced by one of the proper approximations to 0, appearing at some stage before γ. Since the approximations remain unchanged until the next program halts, the proper approximations are all writable, and consequently z is computable from a writable oracle. Thus, z must itself be writable, contradicting our assumption that 0 < ∞ z. We conclude that no such z exists. Theorem The theorem generalizes easily to oracles: Theorem 2.2 For any real a there is no real z such that a < ∞ z < ∞ a. Indeed, for any oracle A there is no real z such that A < ∞ A⊕ z < ∞ A. Proof: Suppose towards a contradiction that A < ∞ A⊕ z < ∞ A = A⊕h. Thus, with A and h as oracles there is a program p yielding a halting computation on input 0 with output z. With only the oracle A, now, consider the algorithm which computes approximations to h and for each of these approximations, together with A, attempts to write z with program p. If none of the proper approximations is able to produce z in this way then z will only appear after the true approximation to h appears, and so from A and z we could recognize h, contradicting A ⊕ z < ∞ A. Thus, it must be that with oracle A and one of the proper approximations to h, §2 A negative solution to Post’s problem for supertasks 7 we can write z. Since all such proper approximations are A-writable, it follows that z is A-writable, contradicting A < ∞ A⊕ z. Theorem The non-existence of real degrees between a real a and it’s jump a means of course that the structure of the supertask degrees differs remarkably from the classical analogue. The Sack’s Density theorem, for example, obviously cannot hold in the context of the supertask degrees on the reals. Does it hold for supertask degrees in general, that is, in the context of sets of reals? Let us emphasize that while the previous theorems show that there are no noncomputable reals below 0, the results of section four will show that there is a rich degree structure between 0 and 0 when it comes to sets of reals. In particular, we will show that there are many degrees A such that 0 < ∞ A < ∞ 0. This is what makes the next corollary so intriguing. Lowness Corollary 2.3 Every degree below 0 is low. That is, if A < ∞ 0, then A ≡ ∞ 0. In fact, for any degree A, if 0 6≤ ∞ A then A = A⊕ 0. Proof: Certainly A ⊕ 0 ≤ ∞ A since A computes both A and 0. If 0 6≤ ∞ A and A⊕ 0 < ∞ A, then A < ∞ A⊕ 0 < ∞ A, contradicting the previous theorem. Consequently, if 0 6≤ ∞ A then it must be that A ≡ ∞ A ⊕ 0. Therefore, in particular, if A < ∞ 0 then certainly 0 6≤ ∞ A and so A ≡ ∞ A ⊕ 0 ≡ ∞ 0. So A is low, as desired. Corollary Corollary 2.4 More generally, for any real b ≤ ∞ A, if b 6≤ ∞ A, then A ≡ ∞ A⊕b. And if b ≤ ∞ A < ∞ b then A ≡ ∞ b. Proof: This general argument is no more difficult. Suppose that b ≤ ∞ A and b 6≤ ∞ A. Then certainly A ⊕ b ≤ ∞ A. If they are not equivalent, then A < ∞ A ⊕ b < ∞ A, contradicting the theorem. Similarly, if b ≤ ∞ A < ∞ b then A ≡ ∞ A⊕ b ≡ ∞ b, as desired. Corollary Perhaps the main idea behind the proof of the Main Theorem is the following principle: Theorem 2.5 For any oracle A we have 0 ≤ ∞ A if and only if λ < λ. Indeed, whenever A ≤ ∞ B, then A ≤ ∞ B if and only if λ < λ. Proof: If B computes A then B can write a real coding the pre-order in which p⊳q when φp (0) halts before φ A q (0), which by results in [HamLew] has order-type λ . Conversely, if B can write a real coding λ, then B knows how to long to wait for the A-computations to halt, and so it can compute h. Since A ≤ ∞ B, this means that A ≤ ∞ B. Theorem §3 The eventually and accidentally writable degrees 8 §3 The eventually and accidentally writable degrees Given that in the reals there are no degrees between 0 and 0, and more generally no reals between any real a and a, it is natural to iterate the jump ▽ operator and the build a kind of backbone to the supertask degrees, namely, the following sequence 0, 0, 0 2 , . . . , 0 α , . . . We simply apply the▽ operator at successor stages, and take a kind of sum at limit stages, using a real coding the ordinal in question. Specifically, we inductively define 0 α y , whenever y is a real coding a relation ⊳ on ω with order type α. At successor stages, if y codes α+ 1, we simply apply the ▽ operator: 0 α+1 y = (0 α y↾α). At limit stages, when y codes a limit ordinal α, we take a sum: 0 α y = ⊕y{ 0 ▽ β y↾β | β < α }, where we use the real y to organize the information. That is, with suitable coding 0 α y is the set { 〈n, 0 ▽ β y↾β 〉 | n has order type β in ⊳ }. Of course, in the notation 0 α y the superscript α is redundant, since y codes α, but we nevertheless retain it for the suggestion that we are iterating the▽ operator; later for eventually writable ordinals α we will give an independent meaning to 0 α free of any code for α. Perhaps the clearest way to picture 0 α y is as an α × ω matrix whose rows are organized using the relation coded by y; the 0 row is trivial, the next row is always the ▽ of the previous row, and the limit rows are the sum, organized using the corresponding restriction of y, of the previous rows. It is a relatively straightforward exercise, by considering the programs which halt if a specific bit of the oracle is on or off, to verify that y itself is computable from 0 α y . There is, of course, a natural connection between this backbone sequence and the eventually writable degrees. In [HamLew] and in the proof of Theorem 2.1, we argued that the halting problem 0 is eventually writable; one simply embarks on the supertask algorithm which simulates all programs on input 0, waits for them to halt and keeps track of which ones have halted. At every stage one has an approximation to 0, namely, the set of programs which have halted by that stage. Eventually, of course, the simulations will have proceeded long enough that every program which will ever halt has already halted, and the true stage is reached, the §3 The eventually and accidentally writable degrees 9 stage by which the approximation to 0 is 0 itself. The conclusion is that 0 is eventually writable. The same argument shows that if a real z is eventually writable, then so is z; one simply embarks on the computation which eventually writes z, and for each approximation to z encountered along the way, embark on the simulation of all computations which on input 0 use this real as an oracle and, by keeping track of which programs have halted, obtain an approximation to z. Eventually, the true approximation to z appears, and after this, after all the computations which halt using z as an oracle have halted, the correct z is eventually written. For any real z let us define the proper approximations to z as the approximations which appear on the output tape, using z as an oracle, before the true approximation appears. Thus, the proper approximations to z are simply the sets of programs which, with z as an oracle, halt before some given z-clockable stage. More generally still, piling approximation upon approximation, one can iterate this idea given a code y for any ordinal α. One simply uses y to organize an α× ω matrix, placing all 0s in the 0 row, and using each row as an oracle to approximate its jump in the next row. Each limit row β is simply the sum of the information in the previous rows, using y ↾β to organize the sum. Thus, for example, the algorithm waits for programs to halt in order to approximate 0 in the first row, and for each such approximation it waits for programs to halt on that oracle to approximate 0 2 in the second row, and so on. Each time a new program halts in some row β, we update the approximation in row β and completely erase the approximations appearing in all rows above β (since they depended on incorrect information in row β). In order to avoid the accumulating garbage at limits of these erasures, we also completely erase any row at a stage which is a limit of stages where we erased that row (since these approximations also depend on incorrect information). Eventually, the first row will attain the true approximation to 0, and will never subsequently be erased. Gradually every row in turn will similarly stabilize, and in the end we will have eventually written 0 α y . What the procedure shows is that 0 α y is eventually y-writable. Consequently, if y itself is eventually writable, then 0 α y is eventually writable. Perhaps this procedure, in which the approximations to an eventually writable real are used to generate further approximations which are in turn used for further approximations and so on transfinitely, can best be viewed as a kind of transfinite-injury priority construction. We injure the approximations to the later iterates when we learn new, better information about the earlier iterates. §3 The eventually and accidentally writable degrees 10 Let us define the proper approximations to 0 α y , with oracle y coding α, as the reals coding the α× ω matrices (organized using y) which appear in the preceding transfinite-injury computation before the true approximation appears. Proper Approximation Lemma 3.1 The proper approximations to z made with oracle z are all z-writable. Similarly, if y codes α, then the proper approximations to 0 α y are y ⊕ 0 ▽ β y↾β -writable for some β < α. Proof: The proper approximations to z are simply the sets of programs which, using oracle z, halt by a given z-clockable stage. Such sets are clearly z-writable. Suppose that z is the proper approximation to 0 α y appearing at stage ξ in the transfinite-injury computation just previously described. By stage ξ there is a certain maximal portion 0 ▽ β y↾β of the oracle which has been correctly computed, and the approximations are only changing in the rows from β to α. Since the approximation is not yet correct in row β, there must be some stage δ > ξ and a program p which halts in row β, in the approximation to 0 ▽ β+1 y↾β+1. And since this is the first time for p to halt in row β after the true 0 ▽ β y↾β has appeared, it must be that δ is y ⊕ 0 ▽ β y↾β -clockable. Consequently, ξ is y ⊕ 0 ▽ β y↾β -writable. Thus, with y⊕ 0 ▽ β y↾β as an oracle, we can stop the original construction at stage ξ, and thereby write z, as desired. Lemma The next lemma is a generalization of the Main Theorem. Whereas the Main Theorem shows that there are no reals between any a and a, the following lemma shows more, that no reals sneak into the limit stages in the transfinite iteration of the ▽ operator. Continuity Lemma 3.2 If y is an x-writable real coding the ordinal α and x ≤ ∞ 0 α y , then x ≡ ∞ y ⊕ 0 ▽ β y↾β for some β ≤ α. Proof: Let us suppress the subscript y, using always y or the appropriate restriction y ↾ β as the case may be. Consider the algorithm which with oracle x first writes y and then computes approximations to 0 α by recursion along the order given by y, in the transfinite-injury manner previously described. Since x is computed by some program p on input 0 using the oracle 0 α , we can for each of our approximations simulate the operation of program p using the approximation as our oracle. If x only appears after the true approximation 0 α is produced, then we could recognize 0 α as the first approximation able to produce x and thereby conclude x ≡ ∞ y⊕0 α . Alternatively, suppose one of the proper approximations to 0 α is able to produce x. By the previous lemma, all such proper approximations are y ⊕ 0 β -writable §3 The eventually and accidentally writable degrees 11 for some β < α. And since we could use x to recognize the first approximation to produce x, we conclude that x ≡ ∞ y ⊕ 0 β for some β < α, as desired. Lemma Continuity Corollary 3.3 In particular, if y is a writable real coding α, then every x computable from 0 α y is equivalent to 0 ▽ β y↾β for some β ≤ α. Often, we only care about the degree of 0 α y , rather than the particular instantiation with the particular code y; the next lemma shows that provided one does not try to sneak undue complexity into these codes, the degree of 0 α y does not depend on y. Specifically, we define that y and z, both coding the same ordinal α, are hereditarily equivalent when for every β ≤ α we have y ↾ β ≡ ∞ z ↾ β. Any two writable reals coding the same ordinal, for example, are hereditarily equivalent. Lemma 3.4 If y and z are hereditarily equivalent, then 0 α y ≡ ∞ 0 α z . Proof: We prove this by a straightforward induction on α, the ordinal coded by y and z. For the successor case, suppose that y and z both code the ordinal α+ 1 and inductively, that 0 α y↾α ≡ ∞ 0 α z↾α . By taking the ▽ of both sides, it follows that 0 α+1 y ≡ ∞ 0 α+1 z . For the limit case, suppose that y and z both code the limit ordinal α, and that y ↾ β ≡ ∞ z ↾ β for all β ≤ α. Inductively, we may assume that 0 ▽ β y↾β ≡ ∞ 0 ▽ β z↾β for β < α. Since at α we simply take the sums of these, we need only argue by symmetry that from 0 α y we can uniformly compute 0 ▽ β z↾β . Given 0 α y we can write y and z and begin to compute each 0 ▽ β z↾β . At limit rows we simply take the sum of what we have computed so far. At successor rows, given 0 ▽ β z↾β , we search for (and find) the program which witnesses the forward reduction in the equivalence 0 ▽ β y↾β ≡ ∞ 0 ▽ β z↾β and then use that program to translate the jump of the former (which we can compute from 0 α y ) to the jump of the latter, thereby producing 0 ▽ β+1 z↾β+1, as desired. Lemma We now define 0 α , when α is a writable ordinal, to be the degree of 0 α y where y is a writable real coding α. Since any two writable reals coding α are hereditarily equivalent, 0 α is well-defined. We thereby obtain the backbone sequence of degrees 0, 0, . . . , 0 α , . . . by iterating through the writable ordinals. Backbone Continuity Theorem 3.5 The backbone sequence, iterated through the writable ordinals, is continuous; namely, whenever α is a writable limit ordinal, 0 α is a minimal upper bound of 0 β for β < α. Proof: This follows immediately by Corollary 3.3. Theorem §3 The eventually and accidentally writable degrees 12 By the end of this section, we aim to show the same result for the iterations through the eventually writable ordinals and what is more, that this backbone sequence exhausts the eventually writable degrees. In particular, the eventually writable degrees are well-ordered! Thus, in the previous theorem we will actually know that 0 α is the least eventually writable upper bound to the 0 β . In order to prove these things, let us develop a bit of the theory of the eventually and accidentally writable degrees. We say that a real appears at time α when it is written on one of the tapes at stage α during the (possibly non-halting) supertask computation of some program p on input 0. Timing Theorem 3.6 (Welch) Just as the writable reals are those appearing before time λ on an infinite time Turing computation with input 0, the eventually writable reals are those which appear before time ζ, and the accidentally writable reals are those which appear before time Σ. Proof: Perhaps this is implicit in [Wel98a]. Every writable real appears of course at a clockable stage, and therefore before stage γ = λ. Conversely, it is not difficult to argue that any real which appears at a writable stage is writable. Skipping now to the accidentally writable reals, Lemma 1.2 shows that any computation on input 0 either halts before λ or else obtains its repeating snapshot by stage ζ, repeating it by stage Σ. Thus, any accidentally writable real must appear before stage Σ. And obviously any real which appears before Σ is accidentally writable. Considering now the eventually writable reals, if a real z appears before stage ζ during the computation of program p on input 0, then we could eventually write a real coding the ordinal stage when it appeared, and simultaneously eventually write the real appearing at that stage in the computation of p on input 0, thereby eventually writing z. Conversely, if a real z is eventually writable, then since it must appear before stage Σ we could, while computing approximations to z, search for a real coding an ordinal long enough to see that z has appeared, and thereby succeed in eventually writing a real coding the ordinal stage at which z first appeared. So this must be an eventually writable ordinal. Theorem Longest Computation Lemma 3.7 There is a single program p which on input 0 takes as long as is possible to repeat, namely, it first attains its repeating snapshot at stage ζ, first again repeated at stage Σ. Proof: This lemma was also observed by Welch. Note that Lemma 1.2 establishes that the stage ζ snapshot of any supertask computation on input 0 repeats again at stage Σ. The issue is whether this snapshot appears also before ζ or between ζ §3 The eventually and accidentally writable degrees 13